<!DOCTYPE html>
<!--[if lt IE 7]> <html class="no-js ie6" lang="en"> <![endif]-->
<!--[if IE 7]>    <html class="no-js ie7" lang="en"> <![endif]-->
<!--[if IE 8]>    <html class="no-js ie8" lang="en"> <![endif]-->
<!--[if gt IE 8]><!-->  <html class="no-js" lang="en"> <!--<![endif]-->
<head>
	<meta charset="utf-8">
	<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
	
	<title>Adapter</title>
	
	<meta name="description" content="A jQuery library for modern HTML presentations">
	<meta name="author" content="Caleb Troughton">
	<meta name="viewport" content="width=1024, user-scalable=no">
	
	<!-- Core and extension CSS files -->
	<link rel="stylesheet" href="../core/deck.core.css">
	<link rel="stylesheet" href="../extensions/goto/deck.goto.css">
	<link rel="stylesheet" href="../extensions/menu/deck.menu.css">
	<link rel="stylesheet" href="../extensions/navigation/deck.navigation.css">
	<link rel="stylesheet" href="../extensions/status/deck.status.css">
	<link rel="stylesheet" href="../extensions/hash/deck.hash.css">
	<link rel="stylesheet" href="../extensions/scale/deck.scale.css">
	
	<!-- Style theme. More available in /themes/style/ or create your own. -->
	<link rel="stylesheet" href="../themes/style/swiss.css">
	
	<!-- Transition theme. More available in /themes/transition/ or create your own. -->
	<link rel="stylesheet" href="../themes/transition/horizontal-slide.css">
	
	<script src="../modernizr.custom.js"></script>
	

    <!-- SintaxHighlighter -->
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
	<title>SyntaxHighlighter Large File Demo</title>
	<script type="text/javascript" src="../SyntaxHighlighter-master/scripts/XRegExp.js"></script>
	<script type="text/javascript" src="../SyntaxHighlighter-master/scripts/shCore.js"></script>
	<script type="text/javascript" src="../SyntaxHighlighter-master/scripts/shBrushJava.js"></script>
	<script type="text/javascript" src="../SyntaxHighlighter-master/scripts/shBrushPlain.js"></script>
	<script type="text/javascript" src="../SyntaxHighlighter-master/scripts/shBrushPython.js"></script>
	<link type="text/css" rel="stylesheet" href="../SyntaxHighlighter-master/styles/shCoreEclipse.css"/>
	<!--link type="text/css" rel="stylesheet" href="../SyntaxHighlighter-master/styles/shThemeEclipse.css"/-->
	
	<script type="text/javascript">SyntaxHighlighter.all();</script>

	
	
</head>

<body class="deck-container">

<!-- Begin slides -->
<section class="slide" id="strategy1">
	<h2>Adapter</h2>
	<h3>Adaptadores de Objetos</h3>
	<p>Supongamos que tenemos un software que necesitamos hacer andar una nueva libreria que tiene un diseño distinto en la interfaces que el software base.</p>
	<img src="adapter1.png"/>
	<p>No queremos tocar el codigo del software de base y no podemos cambiar el codigo de las librerias. Lo que podemos hacer es escribir una clase que adapte la interfaz de la libreria a la del software que tenemos.</p>
	<img src="adapter2.png"/>

</section>

<section class="slide" id="adapter2">
	<h2>Adapter</h2>
	<p>Acemos una version distinta de la implementacion de los patos para ver el adapter y agregamos pavos que implementan una interfaz distinta.</p>
	<p>La interfaz de los patos</p>
	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
		public interface Duck {
			public void quack();
			public void fly();
		}
	</script>
	<p>Vemos como queda un pato cuando implemneta la interfaz Duck</p>
	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
		public class MallardDuck implements Duck {
			public void quack() {
				System.out.println("Quack");
			}
		 
			public void fly() {
				System.out.println("I'm flying");
			}
		}
	</script>
</section>

<section class="slide" id="adapter3">
	<h2>Adapter</h2>
	<p>Ahora la interfaz de los pavos</p>
	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
		public interface Turkey {
			public void gobble();
			public void fly();
		}
	</script>
	<p>Vemos como queda un pavo cuando implemneta la interfaz Duck</p>
	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
		public class WildTurkey implements Turkey {
			public void gobble() {
				System.out.println("Gobble gobble");
			}
		 
			public void fly() {
				System.out.println("I'm flying a short distance");
			}
		}
	</script>
</section>

<section class="slide" id="adapter4">
	<h2>Adapter</h2>
	<p>Si queresmos usar <strong>pavos</strong> en donde esperamos <strong>patos</strong>, como guardar en un variable Duck un Turkey, o pasar un Turkey por parámetro como si fuera un Duck, necesitamos el adaptador que haga que el Turkey parezca un Duck.</p>
	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
		public class TurkeyAdapter implements Duck {
			Turkey turkey;
			public TurkeyAdapter(Turkey turkey) {
				this.turkey = turkey;
			}
			public void quack() {
				turkey.gobble();
			}
			public void fly() {
				for(int i=0; i < 5; i++) {
					turkey.fly();
				}
			}
		}
	</script>
	<ol>
		<li>Implementamos la interfaz del tipo que esperamos.<BR/>
			Por ejemplo esperamos un parametro tipo Duck, pero queremos que contenga un objeto tipo Turkey.<BR/>
			O en el caso de un método espera un tipo de parametro Duck y queremos pasarle uno tipo Turkey</p>
		<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
			static void testDuck(Duck duck) {
				duck.quack();
				duck.fly();
			}
		</script>
		</li>
	</ol>	
</section>
<section class="slide" id="adapter4b">
	<h2>Adapter</h2>
	<ol start=2>
		<li>En el contructor le pasamos el tipo incompatible al que queremos adaptarlo, lo disfrasamos para que parezca de otra interface. En este caso Turkey
		<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
			public TurkeyAdapter(Turkey turkey) {
				this.turkey = turkey;
			}
		</script>
		</li>
		<li>Como implementamos Duck tenemos que implemnetar quack() y fly() y aca es donde hacemos la traduccion. Cuando llamemos a quack() en realidad el pavo a a ejecutar gobble()
		<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
			public void quack() {
				turkey.gobble();
			}
			public void fly() {
				for(int i=0; i < 5; i++) {
					turkey.fly();
				}
			}
		</script>
		</li>
	</ol>	
</section>
<section class="slide" id="adapter5">
	<h2>Adapter</h2>
	<h3>Testeamos el adapter</h3>
	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
		public class DuckTestDrive {
			public static void main(String[] args) {
				MallardDuck duck = new MallardDuck();
		 		//creamos un pato

				WildTurkey turkey = new WildTurkey();
				//creamos un pavo

				Duck turkeyAdapter = new TurkeyAdapter(turkey);
		   		//envolvemos al pavo con el adapter y nos queda un pato

				System.out.println("The Turkey says...");
				turkey.gobble();
				turkey.fly();
		 
				System.out.println("\nThe Duck says...");
				testDuck(duck);
		  
				System.out.println("\nThe TurkeyAdapter says...");
				testDuck(turkeyAdapter);
				//llamamos al metodo pasandole un pavo adaptado
			}
		 
			static void testDuck(Duck duck) {
				duck.quack();
				duck.fly();
			}
		}
	</script>
</section>

<section class="slide" id="adapter6">
	<h2>Adapter</h2>
	<h3>Paso a paso lo que hicimos</h3>
	<ol>
		<li>El cliente hace la llamada al adaptador llamando a algun método de la interfaz destino.<BR/>
		En este caso la interfaz destino es Duck.
		<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
			new TurkeyAdapter(new WildTurkey()).quack();
		</script>
		</li>
		<li>El adaptador traduce las llamadas en uno o muchas llamadas al objeto envuelto o contenido por el adapter. En este caso Turkey
		<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
			public void quack() {
				turkey.gobble();
			}
		</script>
		</li>
		<li>El cliente recibie los resultados sin saber que hubo un adapter en el medio haciendo la traduccion.</li>
	</ol>	
</section>
<section class="slide" id="adapter6a">
	<h2>Adapter</h2>
	<h3>Principios de OO en el adapter</h3>
	<ol>
		<li>Usamos la composición para envolver adaptee con una interfaz alterada. Esto tiene la ventaja que podemos usar un adapter con cualquier sublcase del adapter.</li>
		<li>También vemos como el patron enlaza al cliente a una interface no a una implementación, esto significa que podemos usar varios adapters, cada uno adaptando un grupo diferente de clases, o le podemos agregar nuevas implementaciones mientras se implemente la interfaz target.</li>
	</ol>	
</section>

<section class="slide" id="adapter9">
	<h2>Patron Adapter</h2>
	<p>Convierte la interfaz de una clase en otra interfaz que el cliente espera. Adapter deja comunicarse a clases que de otra forma no podrían hacerlo por incompatibilidades de interface.</p>
	<ul>
		<li>Motivación: Cuando tenemos una clase, parametro o varible de instancia que espera una interfaz, y tenemos una que ofrese la misma funcionalidad pero con una interface diferente, y queremos que se puedan comunicar si tener que hacer cambios en el codigo de las clases intervinientes</li>
		<li>Aplicabilidad: 
		<ul>
			<li>Queremos utilizar una clase ya existente, pero cuya interfaz no coincide con la que necesitas</li>
			<li>Queremos crear una clase reutilizable que coopere con otras no relacionadas, es decir, con clases que puedan no tener una interfaz compatible</li>
			<li>Necesites usar varias subclases existentes pero no sea práctico adaptar sus interfaces. Un object adapter puede adaptar la interfaz de la clase padre.</li>
		</ul>	
		</li>
	</ul>	
</section>
<section class="slide" id="adapter10">
	<h2>Patron Adapter</h2>
	<ul>
		<li>Participantes: 
		<ul>
			<li><strong>Target:</strong> define la interfaz específica de dominio que el cliente usa</li>
			<li><strong>Client:</strong> colabora con los objetos que implementan la interfaz definida por el target</li>
			<li><strong>Adaptee:</strong> define una interfaz existente que necesita adaptarse</li>
			<li><strong>Adapter:</strong> adapta la interfaz del objeto adaptado a la definida por el target</li>
		</ul>	
		</li>
		<li>Consecuencias:
		<ul>
			<li>Object adapter: 
			<ul>
				<li>Un adapter funciona con varios adaptees (el mismo adaptee y todas sus subclases)</li>
				<li>Dificulta sobrescribir el comportamiento del adaptee</li>
			</ul>	
			</li>
			<li>Class adapter: 
			<ul>
				<li>El adapter hereda el comportamiento del adaptee, y puede sobrescribirlo</li>
				<li>No sirve para adaptar una clase y todas sus subclases</li>
				<li>Introduce un único objeto, no hace falta un nivel de indirección para obtener el adaptee</li>
			</ul>
			</li>
		</ul>	
		</li>	
	</ul>	
</section>
<section class="slide" id="adapter10">
	<h2>Patron Adapter</h2>
	<ul>
		<li>			
			<p>Obeject Adapter</p>
			<img src="adapterClassDiagram.png"/>
		</li>
		<li>
			<p>Class Adapter</p>
			<img src="classAdapterClassDiagram.png"/>
		</li>
	</ul>	
</section>

<section class="slide" id="adapter11">
	<h2>Adapter</h2>
	<h3>Object Adapter y Class Adapter</h3>
	<p>Hay dos implementaciones del patrón Adapter, Object Adapter y Class Adapter</p>
	<ul>
		<li>
			<p>Object Adapter</p>
			<p>Pros:</p>
			<ul>
				<li>Más flexible que class Adapter</li>
				<li>No requiere usar herencia</li>
				<li>Adapter funciona con Adaptee y todas sus subclases</li>
			</ul>
			<p>Contras:</p>
			<ul>
				<li>Más difícil sobreescribir el comportamiento de Adaptee</li>
				<li>Requiere más código en la implementación</li>
			</ul>
		</li>
		<li>
			<p>Class Adapter</p>
			<p>Pros:</p>
			<ul>
				<li>menos codigo que object adapter</li>
				<li>puede sobreescribir el comportamiento de Adaptee si se requiere</li>
			</ul>
			<p>Contras:</p>
			<ul>
				<li>Requiere hacer uso de herencia (herencia simple)</li>
				<li>Menos felxible que object Adapter</li>
			</ul>
		</li>
			
	</ul>	
</section>
<section class="slide" id="adapter16">
	<h2>Facade</h2>
	<h3>Nos armamos un cine en casa completo</h3>
	<p>Vemos el diagrama de clases de todos los dispositivos con las conexiones</p>
	<img src="ht.png"/>
</section>
<section class="slide" id="adapter17">
	<h2>Facade</h2>
	<p>El problema es hacer que ande. El procedimieto sería el siguiente: </p>
	<ol>
		<li>prender la maquina de pochoclo en on</li>
		<li>poner iniciar para que arranque</li>
		<li>bajar las luces</li>
		<li>bajar la pantalla</li>
		<li>prender el proyector</li>
		<li>setear la entrada del proyector en dvd</li>
		<li>poner el proyectro en modo winde screen</li>
		<li>setear el amplificador en DVD input</li>
		<li>poner el amplificador en modo surround</li>
		<li>poner el volumen del amplificador en 5</li>
		<li>prender el dvd player</li>
		<li>poner play en el dvd</li>
	</ol>
	<p>En código sería</p>
	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
		popper.on();
		popper.pop();
		lights.dim(10);
		screen.down();
		projector.on();
		projector.wideScreenMode();
		amp.on();
		amp.setDvd(dvd);
		amp.setSurroundSound();
		amp.setVolume(5);
		dvd.on();
		dvd.play(movie);
	</script>
</section>
<section class="slide" id="adapter18">
	<h2>Facade</h2>
	<p>Con facade podemos tratar un subsistema complejo y hacerlo fácil de usar implementando la clase facade que provee una interface más razonable</p>
	<img src="facadeHt.png"/>
</section>
<section class="slide" id="adapter19">
	<h2>Facade</h2>
	<h3>Procedimiento</h3>
	<ol>
		<li> Para hacer el facade creamos una clase nueva HomeTheaterFacade, lo que expone unos pocos y simples métodos como wathMovie().</li>
		<li>La clase Facade toma al home theater como un subsistema, y hace llamadas en el subsistema para implementar watchMovie().</li>
		<li>El código de cliente llama a los métodos del home theater Facade, no hace llamadas a los subsistemas. Ahora cuando queremos ver una película llamamos a un sólo método watchMovie() y este se comunica con las luces, DVD player, proyector, amplificador, pantalla, y pochoclera.</BR>
		Esto hace que quede desacoplada la implementacion del cliente de cualquier sistema.</BR>
		Supongamos que queremos actualizar el hometheater cambiando todos los componentes. Si codeamos el cliente para que use el facade, en ves de el subsistema, no hay que cambiar nada en el cliente, pero si hay que cambiar el facade.
		</li>
		<li>Facade deja al subsistema accesible para ser usado directamente. Si necesitamos una funcionalidad especial igual tenemos acceso al subsistema. En realidad no encapsula al subsistema de bajo nivel, simplemente provee una interface simplificada.</li>
	</ol>
</section>
<section class="slide" id="adapter20">
	<h2>Facade</h2>
	<h3>Facade y adapter</h3>
	<p>La diferencia entre adapter y facade es que adapter envuelve ona clase y facade representa muchas clases?</p>
	<p>No, adapter cambia la interface de una o más clases, en uno interface que el cliente esta esperando. Mientras la mayoríaa de los ejemplos de adapter son adaptando una sola clase puede que haya que implementar varias interfaces para proveer la interface que el cliente esta esperando.</p>
	<p>En cambio facade puede proveer una interfaz simplificada a una sola que tenga una interfaz compleja.</BR>
	La principal diferencia no es cuantas clases envuelve uno o el otro sino su intencion, la intencion del adapter es alterar una interface para hacer coincidir con la que el cliente espera y la intension de facade es proveer una interface simplificada a un subsistema.</p>
</section>
<section class="slide" id="adapter20b">
	<h2>Facade</h2>
	<h3>Implementando el facade</h3>
	<p>Usamos composición para acceder para que el facade pueda acceder a todos los componetes del subsistema</p>
	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
	public class HomeTheaterFacade {
		Amplifier amp;
		Tuner tuner;
		DvdPlayer dvd;
		CdPlayer cd;
		Projector projector;
		TheaterLights lights;
		Screen screen;
		PopcornPopper popper;
	 
		public HomeTheaterFacade(Amplifier amp, 
					 Tuner tuner, 
					 DvdPlayer dvd, 
					 CdPlayer cd, 
					 Projector projector, 
					 Screen screen,
					 TheaterLights lights,
					 PopcornPopper popper) {
	 
			this.amp = amp;
			this.tuner = tuner;
			this.dvd = dvd;
			this.cd = cd;
			this.projector = projector;
			this.screen = screen;
			this.lights = lights;
			this.popper = popper;
		}

	</script>
</section>
<section class="slide" id="adapter20c">
	<h2>Facade</h2>
	<h3>Implementando el facade</h3>
	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
	.
		public void watchMovie(String movie) {
			System.out.println("Get ready to watch a movie...");
			popper.on();
			popper.pop();
			lights.dim(10);
			screen.down();
			projector.on();
			projector.wideScreenMode();
			amp.on();
			amp.setDvd(dvd);
			amp.setSurroundSound();
			amp.setVolume(5);
			dvd.on();
			dvd.play(movie);
		}
	 
	 
		public void endMovie() {
			System.out.println("Shutting movie theater down...");
			popper.off();
			lights.on();
			screen.up();
			projector.off();
			amp.off();
			dvd.stop();
			dvd.eject();
			dvd.off();
		}
		//resto de los métodos
	}
	
	</script>
</section>
<section class="slide" id="adapter20d">
	<h2>Facade</h2>
	<h3>Usando el facade</h3>

	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
		public class HomeTheaterTestDrive {
			public static void main(String[] args) {
				//cramos los componentes
				Amplifier amp = new Amplifier("Top-O-Line Amplifier");
				Tuner tuner = new Tuner("Top-O-Line AM/FM Tuner", amp);
				DvdPlayer dvd = new DvdPlayer("Top-O-Line DVD Player", amp);
				CdPlayer cd = new CdPlayer("Top-O-Line CD Player", amp);
				Projector projector = new Projector("Top-O-Line Projector", dvd);
				TheaterLights lights = new TheaterLights("Theater Ceiling Lights");
				Screen screen = new Screen("Theater Screen");
				PopcornPopper popper = new PopcornPopper("Popcorn Popper");
		 		
				//se los pasamos al facade en el contructor	
				HomeTheaterFacade homeTheater = 
						new HomeTheaterFacade(amp, tuner, dvd, cd, 
								projector, screen, lights, popper);
		 
				homeTheater.watchMovie("Raiders of the Lost Ark");
				homeTheater.endMovie();
			}
		}
	</script>
</section>
<section class="slide" id="adapter20z">
	<h2>Facade</h2>
	<h3>Facade y Command</h3>
	<p>Ambos ocultan la complejidad de los subsistemas y proveen una forma facil usar la interface del clientes</p>
	<p>Facade se usa para ocultar la estructura interna y provee una interfaz simplificada, al mismo tiempos uqe daja las interfaces de bajo nivel disponibles en el caso que se necesite alguna funcionalidad extra</p>
	<p>Command se usa para encapsular acciones que permiten usar la funcionalidad, ademas de undo, tareas y colas</p>
</section>
<section class="slide" id="adapter21">
	<h2>Patrón Facade</h2>
	<p>Provee una interfaz unificada a un conjunto de interfaces en un subsistema. Define una interfaz de alto nivel que facilita el uso del subsistema.</p>
	<ul>
		<li>Clasificación: Es un patrón estructural.</li>
		<li>Motivación: Reducir su complejidad con la división en subsistemas, minimizando las comunicaciones y dependencias entre éstos.
		</li>
		<li>Aplicabilidad:
			<ul>
				<li>Se quiera proporcionar una interfaz sencilla para un subsistema complejo</li>
				<li>Se quiera desacoplar un subsistema de sus clientes y de otros subsistemas, haciéndolo mas independiente y portable</li>
				<li>Se quiera dividir los sistemas en niveles: las fachadas serían el punto de entrada a cada nivel</li>
			</ul>
		</li>
	</ul>
</section>
<section class="slide" id="adapter22">
	<h2>Patrón Facade</h2>
	<ul>
		<li>Participantes:
			<ul>
				<li><strong>Fachada:</strong> : delegar las peticiones de los clientes en los objetos del subsistema</li>
				<li><strong>Clases del subsistema:</strong> implementar la funcionalidad del subsistema.</li>
			</ul>
		</li>
		<li>Consecuencias:
			<ul>
				<li>Oculta a los clientes de la complejidad del subsistema y lo hace más fácil de usar</li>
				<li>Favorece un acoplamiento débil entre el subsistema y sus clientes, consiguiendo que los cambios de las clases del sistema sean transparentes a los clientes</li>
				<li>Facilita la división en capas y reduce dependencias de compilación</li>
				<li>No se impide el acceso a las clases del sistema</li>
			</ul>
		</li>
	</ul>		
</section>
<section class="slide" id="adapter23">
	<h2>Patrón Facade</h2>
	<ul>
		<li>Estructura
			<img src="facadeClassDiagram.png"/>	
		</li>
	</ul>	
</section>
<section class="slide" id="adapter24">
	<h2>Principio de diseño</h2>
	<h3>Menor conocimiento</h3>
	<p>Hablar solo con amigos inmediatos.</p>
	<p>Esto significa que cuando estamos diseñando un sistema, seamos cuidadosos en la cantidad de clases que interactuan, y tambien como interactuan.</p>
	<p>Este principio nos previene de crear diseños que tienen gran número de clases acopladas lo que ocasiona que los cambios impacten en cascada en otras partes, esto hace que un sistema sea frágil, difícil de mantener, y complejo de entender.</p>
	<p><strong>Guias de como seguir el principio</strong><p>
	<p>Tomamos un objeto, desde cualquier método del objeto, el principio nos dice que debemos invocar métodos que sólo pertenezcan a:</p>
	<ul>
		<li>El objeto mismo</li>
		<li>Objetos pasados como parámetro en el método</li>
		<li>Cualquier objeto que el método crea o instancia</li>
		<li>Cualquier componente del objeto</li>
	</ul>
</section>
<section class="slide" id="adapter25">
	<h2>Principio de diseño</h2>
	<h3>Menor conocimiento</h3>
	<p>Cual es el daño de llamar el método de un objeto, que obtenemos de otro?<p>
	<p>Bueno si hacemo eso, le estamos haciendo un requerimiento a otro objeto  e incrementando el numero de objetos que conocemos directamente. En este caso el principio nos fuerza a que el objeto que invocamos haga la invocacion al siguiente objeto por nosotros. De esa manera no tenemos que saber detalles del objeto componente y mantenemos el circulo de amigos pequeño.</p>
	<p><strong>Sin el principio</strong><p>
	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
		public float getTemp(){
			return station.getThermometer().getTemperature();
		}
	</script>	
	<p><strong>Con el principio</strong><p>
	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
		public float getTemp(){
			retrun station.getTemperature();
		}
	</script>		
</section>
<section class="slide" id="adapter26">
	<h2>Principio de diseño</h2>
	<h3>Menor conocimiento</h3>
	<p><strong>Mantener  las llamadas dentro de los límites</strong><p>
	<p>Esta clase auto demuestra todas las formas que se pueden llamar métodos sin violar el principio Menor Conocimiento</p>

	<script type="syntaxhighlighter" class="brush: java; toolbar: false;">
	Public class Car{
		Engine engine; //este es el componente de la clase
		public void start(Key key){
			Doors doors = new Doors(); //crear un objeto nuevo, en el metodo es legal
			boolean authorized = key.turns(); //se puede llamar a un metodo de un objeto llamado como parámetro
			if (authorized){
					engine.start(); //se pueden llamar metodos del compoente
					updateDashboardDisplay(); // se puede llamar a un metodo local del la clase
					doors.lock(); //se puede llamar metodos de objetos creados en el metodo
			}
		}
		public void updateDashboardDisplay(){
		//update display
		}
	}
	</script>	
	<p>La desventaja qeu tiene es que si bien el principio reduce las dependencias entre objetos y estudios demuestran que con esto se reduce el mantenimiento, tambien es cierto que produce mas clases que son envueltas para manejar las llamadas a otros componentes, lo que puede ocacionar mas complejidad, tiempo de desarrollo y performance.</p>
	
</section>
<section class="slide" id="strategy27">
	<h2>Referencias</h2>
	<p>Head First Design Patterns</p>
</section>
<!----------------------------------------------------------------------------------------------->
<!-- deck.navigation snippet -->
<a href="#" class="deck-prev-link" title="Previous">&#8592;</a>
<a href="#" class="deck-next-link" title="Next">&#8594;</a>

<!-- deck.status snippet -->
<p class="deck-status">
	<span class="deck-status-current"></span>
	/
	<span class="deck-status-total"></span>
</p>

<!-- deck.goto snippet -->
<form action="." method="get" class="goto-form">
	<label for="goto-slide">Go to slide:</label>
	<input type="text" name="slidenum" id="goto-slide" list="goto-datalist">
	<datalist id="goto-datalist"></datalist>
	<input type="submit" value="Go">
</form>

<!-- deck.hash snippet -->
<a href="." title="Permalink to this slide" class="deck-permalink">#</a>


<!-- Grab CDN jQuery, with a protocol relative URL; fall back to local if offline -->
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script>
<script>window.jQuery || document.write('<script src="../jquery-1.7.2.min.js"><\/script>')</script>

<!-- Deck Core and extensions -->
<script src="../core/deck.core.js"></script>
<script src="../extensions/hash/deck.hash.js"></script>
<script src="../extensions/menu/deck.menu.js"></script>
<script src="../extensions/goto/deck.goto.js"></script>
<script src="../extensions/status/deck.status.js"></script>
<script src="../extensions/navigation/deck.navigation.js"></script>
<script src="../extensions/scale/deck.scale.js"></script>

<!-- Initialize the deck -->
<script>
$(function() {
	$.deck('.slide');
});
</script>

</body>



</html>
